At present, development of a software project needs a plurality of developers, even needs a plurality of developers from different fields to cooperate, wherein every developer develops a part of the project.
In the present development process of a software project, Project Management Tool (PMT) is used to partition the project, i.e. partition the project into a number of sub-projects; then Integrated Development Environment (IDE) is used to develop every sub-project, for example a source file is created and amended; at the same time Version Control System (VCS) is used to control the versions of the artifacts generated during the development process, for example updating the version of a source file. Most products of VCS, such as Concurrent Versions System (CVS), ClearCase, and Configuration Management Version Control (CMVC), etc., provide strong capability on version control for a user, such as the operations of check in, check out, etc.
In the process of developing and managing a project by using Integrated Development Environment (IDE) and Version Control System (VCS), every developer develops a sub-project assigned from the whole project under the development environment. However, this working mode does not fit the development of some projects with special requirements. For example, there are problems under two conditions as follows:
1) The project has a high confidentiality requirement, and needs a plurality of developers to develop together. In this case, a project manager does not hope that any developer can touch the whole project; therefore, it is an important problem to make sure that every developer can not obtain the content of the whole project;
2) The project is very complex, and the working task relationships among the different developers are very complex too. Generally, it takes the developers much time to solve the development environment problems caused by the related working tasks of other developers.
For the above-mentioned situations, some possible existing solutions include:
Different development environments are manually prepared and provided for different developers, and the whole project is manually partitioned into a number of different sub-projects, then every sub-project is independently developed, and there are no relationships among these sub-projects. Although the method can make sure that every developer can not obtain the content of the whole project, if the whole project is amended, the sub-projects partitioned before are needed to be manually partitioned again from the whole project. The rework of the partition is very normal in the software project, so with the manual method it is hard to avoid a mass of repeated manual efforts. Furthermore, it is time-consuming and error-prone. In addition, the most important thing is that designs and tests of modules are independent of each other in the manual method. For software whose modules are dependent on each other, it is very inconvenient when a developer tests his/her modules which depend on modules developed by other developers. Therefore, in general cases, the pure manual assignment of a development environment is only adopted in the development process of small scale software projects.
The sub-projects developed by different developers can be controlled according to accessing rights using VCS. For example, Project A is partitioned into sub-project A-1, sub-project A-2, and sub-project A-3. The developer for developing the sub-project A-1 can totally control this sub-project, such as reading, amending and submitting a new version, has the right of reading the sub-project A-2 depended by sub-project A-1, but has no right to access sub-project A-3 which is not depended by sub-project A-1. However, if the developer of sub-project A-1 can read all the details of sub-project A-2 developed by another developer, this solution can not achieve the confidentiality requirement for sub-project A-2. In order to make sure that every developer can not obtain the contents of any sub-project that is not developed by himself/herself and achieve confidentiality requirement, it is needed to limit the right for reading the project not developed by himself/herself. However, in the case that the reading right is completely limited, compiling errors will occur. The reason is that the contents of the project which cannot be accessed but needed by the developer can not be provided for the developer by the project development environment due to access control mechanism. However, the content of other sub-projects which is depended is needed for the developer while compiling. If the compiler can not find codes depended, it will notify an error.
Furthermore, a project partition method is disclosed in a patent document US2006/0168556A1 titled “Engineering system for distributed development and development by a number of users”, in which an entirely independent sub-project is partitioned from a whole project and developed by a specific developer. In an actual development process of software, however, a project can not be composed of a plurality of completely independent sub-projects. On the contrary, it can not be avoided that there are dependencies among sub-projects.
Thus, what is needed for a method of providing for a developer the whole development codes without codes that the developer does not need to know. That is to say, the method should be able to make sure that any sub-project obtained by the developer does not contain contents which should not be known by the developer but can be correctly compiled and tested.